package main

import (
	"bufio"
	"fmt"
	"net"
	"os"
	"strings"
    "encoding/hex"
	"log"
	"time"
	"database/sql"
	_ "github.com/go-sql-driver/mysql"
	"strconv"
	//"math"
	//"bytes"
)

// const (
// 	heartbeatInterval = 5 * time.Second  // 心跳包发送间隔
// 	heartbeatTimeout  = 30 * time.Second // 心跳包超时时间
// )

func main() {

	// 监听端口
	ln, err := net.Listen("tcp", "10.16.31.149:8000")
	if err != nil {
		fmt.Println("Error listening:", err.Error())
		os.Exit(1)
	}
	defer ln.Close()
	fmt.Println("Listening on :8000")
	for {
		// 接受连接
		conn, err := ln.Accept()
		if err != nil {
			fmt.Println("Error accepting:", err.Error())
			continue
		}
		fmt.Println("Connection established")

		// 处理连接
		go handleConnection(conn)
	}
}

func HexToDecimalWithTwoDecimalPlaces(hexStr string) (string, error) {
	// 将十六进制字符串转换为字节数组
	bytes, err := hex.DecodeString(hexStr)
	if err != nil {
		return "", fmt.Errorf("error decoding hex string: %v", err)
	}

	// 确保字节数组的长度为4字节
	if len(bytes) != 4 {
		return "", fmt.Errorf("expected 4 bytes, got %d bytes", len(bytes))
	}

	// 将字节数组转换为32位有符号整数
	var intValue int32
	for i := 0; i < 4; i++ {
		intValue = intValue<<8 + int32(bytes[i])
	}

	// 将整数转换为浮点数，并取后两位为小数
	floatValue := float64(intValue) / 100.0

	// 将浮点数格式化为精度为两位的小数
	formattedValue := fmt.Sprintf("%.2f", floatValue)

	return formattedValue, nil
}


func HexToDecimalWithTwoDecimalPlaces1(hexStr string) (string, error) {
	// 将十六进制字符串转换为字节数组
	bytes, err := hex.DecodeString(hexStr)
	if err != nil {
		return "", fmt.Errorf("error decoding hex string: %v", err)
	}

	// 确保字节数组的长度为4字节
	if len(bytes) != 4 {
		return "", fmt.Errorf("expected 4 bytes, got %d bytes", len(bytes))
	}

	// 将字节数组转换为32位无符号整数
	var intValue uint32
	for i := 0; i < 4; i++ {
		intValue = intValue<<8 + uint32(bytes[i])
	}

	// 将整数转换为浮点数，并取后两位为小数
	floatValue := float64(intValue) / 100.0

	// 将浮点数格式化为精度为两位的小数
	formattedValue := fmt.Sprintf("%.2f", floatValue)

	return formattedValue, nil
}

func HexToDecimalWithTwoDecimalPlaces2(hexStr string) (string, error) {
	// 将十六进制字符串转换为字节数组
	bytes, err := hex.DecodeString(hexStr)
	if err != nil {
		return "", fmt.Errorf("error decoding hex string: %v", err)
	}

	// 确保字节数组的长度为4字节
	if len(bytes) != 4 {
		return "", fmt.Errorf("expected 4 bytes, got %d bytes", len(bytes))
	}

	// 将字节数组转换为32位无符号整数
	var intValue uint32
	for i := 0; i < 4; i++ {
		intValue = intValue<<8 + uint32(bytes[i])
	}

	// 将整数转换为浮点数，并取后两位为小数
	floatValue := float64(intValue) / 1000000.0

	// 将浮点数格式化为精度为两位的小数
	formattedValue := fmt.Sprintf("%.6f", floatValue)

	return formattedValue, nil
}


// HexToPrefixedHex 将无符号十六进制字符串转换为带有前缀0x的十六进制字符串
func HexToPrefixedHex(hexStr string) (string, error) {
	// 将十六进制字符串转换为无符号整数
	decimalValue, err := strconv.ParseUint(hexStr, 16, 64)
	if err != nil {
		return "", fmt.Errorf("error converting hex to decimal: %v", err)
	}

	// 将无符号整数转换为带有前缀0x的十六进制字符串
	hexWithPrefix := fmt.Sprintf("0x%X", decimalValue)

	return hexWithPrefix, nil
}

func BytesToHexWithPrefix(data []byte) []string {
	hexBytes := make([]string, len(data))
	for i, b := range data {
		hexBytes[i] = fmt.Sprintf("0x%02X", b)
	}
	return hexBytes
}

func BytesToHex(byteArray []byte) string {
	// 使用strings.Builder来构建最终的十六进制字符串
	var hexBuilder strings.Builder

	// 遍历字节数组，将每个字节转换为十六进制
	for _, b := range byteArray {
		// 使用strconv.Itoa将字节转换为十进制字符串
		// 然后使用strings.Builder的WriteString方法追加格式化后的十六进制字符串
		hexBuilder.WriteString(fmt.Sprintf("%02X", b))
	}

	// 移除最后一个空格并返回结果字符串
	return strings.TrimSpace(hexBuilder.String())
}

func CombineHexWithPrefixPerByte(hexStrings []string) (string, error) {
	// 新的字符串数组，用于存储去除前缀后的十六进制数
	var hexParts []string
	for _, hex := range hexStrings {
		// 去除"0x"前缀，只保留十六进制部分
		hexPart := strings.TrimPrefix(hex, "0x")
		hexParts = append(hexParts, hexPart)
	}

	// 检查所有部分的组合是否是有效的十六进制数
	combinedHex := strings.Join(hexParts, "")
	_, err := strconv.ParseInt(combinedHex, 16, 64)
	if err != nil {
		return "", fmt.Errorf("invalid combined hex string: %s", combinedHex)
	}

	// 构建最终的字符串，每个字节前都有"0x"前缀，并用空格隔开
	finalString := ""
	for _, part := range hexParts {
		finalString += fmt.Sprintf("0x%s ", part)
	}
	// 移除字符串末尾的空格
	finalString = strings.TrimSpace(finalString)

	return finalString, nil
}

func hexToTime(hexStr string) (time.Time, error) {
	// 将输入字符串按空格分割成四个十六进制数
	hexBytes := strings.Fields(hexStr)

	// 确保有四个十六进制数
	if len(hexBytes) != 4 {
		return time.Time{}, fmt.Errorf("input string must contain exactly four hex numbers")
	}

	// 将四个十六进制数转换为一个整数
	var timestamp uint32
	for i, hexByte := range hexBytes {
		// 去除"0x"前缀
		hexByte = strings.TrimPrefix(hexByte, "0x")
		// 将十六进制字符串转换为整数
		value, err := strconv.ParseUint(hexByte, 16, 32)
		if err != nil {
			return time.Time{}, err
		}
		// 根据字节顺序组合整数，注意类型转换为uint32
		timestamp |= uint32(value) << ((3-i) * 8)
	}

	// 将32位整数转换为时间（假设这是自Unix纪元以来的秒数）
	return time.Unix(int64(timestamp), 0), nil
}


var tcpChan = make(chan string, 120)

func handleConnection(conn net.Conn) {
    defer conn.Close()

	// 创建一个心跳包超时的计时器
	// heartbeatTimer := time.NewTimer(heartbeatTimeout)
	
	// go func() {
	// 	for {
	// 		select {
	// 		case <-heartbeatTimer.C:
	// 			// 心跳包超时
	// 			fmt.Println("Heartbeat timeout, closing connection")
	// 			conn.Close()
	// 			return
	// 		}
	// 	}
	// }()

	// 数据库连接信息
	dsn := "root:zhou6706@tcp(10.16.31.149:3306)/"
	// 连接到MySQL服务器
	db, err := sql.Open("mysql", dsn)
	if err != nil {
		log.Fatal(err)
	}
	// 选择数据库
	_, err = db.Exec("USE mydb")
	if err != nil {
		log.Fatal(err)
	}

	// 	createTableSQL := `
	// CREATE TABLE dvinf (	
	// 	SIM卡号 VARCHAR(255),
	// 	群塔ID INT(255),
	// 	塔ID INT(255),
	// 	吊绳倍率 INT(255),
	// 	塔机X坐标 DECIMAL(10, 2),
	// 	塔机Y坐标 DECIMAL(10, 2),
	// 	塔机前臂长度 DECIMAL(10, 2),
	// 	塔机后臂长度 DECIMAL(10, 2),
	// 	塔帽高度 DECIMAL(10, 2),
	// 	塔身高度 DECIMAL(10, 2),
	// 	安装经度 DECIMAL(10, 6),
	// 	安装纬度 DECIMAL(10, 6),
	// 	左转最大角度 DECIMAL(10, 2),
	// 	右转最大角度 DECIMAL(10, 2),
	// 	小车前行最远点到塔臂前端距离 DECIMAL(10, 2),
	// 	小车回收最近到塔臂前端距离 DECIMAL(10, 2),
	// 	钩起升的最高点离塔臂的距离 DECIMAL(10, 2),
	// 	塔机支持的最大起重量 DECIMAL(10, 2),
	// 	力矩限位最大值 DECIMAL(10, 2),
	// 	预警百分比 INT(255),
	// 	报警百分比 INT(255),
	// 	违章百分比 INT(255),
	// 	校验和 VARCHAR(255),
	// 	PRIMARY KEY (SIM卡号)
	// );`
	// _, err = db.Exec(createTableSQL)
	// if err != nil {
	// 	log.Fatal(err)
	// }


	// createTableSQL := `
	// CREATE TABLE dzdata1(	
	// 	上传时间戳 VARCHAR(255),
	// 	吊装开始时间戳 VARCHAR(255),
	// 	吊装结束时间戳 VARCHAR(255),
	// 	最大载重 DECIMAL(10, 2),
	// 	最大载重百分比 INT(255),
	// 	最大力矩 DECIMAL(10, 2),
	// 	最大力矩百分比 INT(255),
	// 	开始转角 DECIMAL(10, 2),
	// 	结束转角 DECIMAL(10, 2),
	// 	开始幅度 DECIMAL(10, 2),
	// 	结束幅度 DECIMAL(10, 2),
	// 	最大工作幅度 DECIMAL(10, 2),
	// 	最小工作幅度 DECIMAL(10, 2),
	// 	开始起升高度 DECIMAL(10, 2),
	// 	结束起升高度 DECIMAL(10, 2),
	// 	最大起升高度 DECIMAL(10, 2),
	// 	最小起升高度 DECIMAL(10, 2),
	// 	最大风速 DECIMAL(10, 2),
	// 	最大倾角X DECIMAL(10, 2),
	// 	最大倾角Y DECIMAL(10, 2),
	// 	设备状态 VARCHAR(255),
	// 	校验和 VARCHAR(255),
	// 	PRIMARY KEY (上传时间戳	)
	// );`
	// _, err = db.Exec(createTableSQL)
	// if err != nil {
	// 	log.Fatal(err)
	// }

	// createTableSQL := `
	// CREATE TABLE rtdata1(	
	// 	上传时间戳 VARCHAR(255),
	// 	高度 DECIMAL(10, 2),
	// 	幅度 DECIMAL(10, 2),
	// 	转角 DECIMAL(10, 2),
	// 	载重 DECIMAL(10, 2),
	// 	安全载重 DECIMAL(10, 2),
	// 	安全载重百分比 INT(255),
	// 	力矩 DECIMAL(10, 2),
	// 	力矩载重百分比 INT(255),
	// 	当前风速 DECIMAL(10, 2),
	// 	倾斜角度X DECIMAL(10, 2),
	// 	倾斜角度Y DECIMAL(10, 2),
	// 	设备状态 DECIMAL(10, 2),
	// 	下降深度 DECIMAL(10, 2),
	//  校验和 VARCHAR(255),
	// 	PRIMARY KEY (上传时间戳	)
	// );`
	// _, err = db.Exec(createTableSQL)
	// if err != nil {
	// 	log.Fatal(err)
	// }

	// createTableSQL := `
	// CREATE TABLE regist(	
	// 	上传时间戳 VARCHAR(255),
	// 	PRIMARY KEY (上传时间戳	)
	// );`
	// _, err = db.Exec(createTableSQL)
	// if err != nil {
	// 	log.Fatal(err)
	// }


	//for {
		// // 从客户端读取数据
		// buffer := make([]byte, 1024)
		// n, err := conn.Read(buffer)
		// if err != nil {
		// 	log.Println("读取数据失败:", err)
		// 	break
		// }

		// // 输出从客户端接收到的数据
		// fmt.Printf("收到客户端数据: %s\n", buffer[5:n])

		// 状态机状态
		state := 0x00
		// 数据包长度
		length := uint16(0)
		// 数据包
		var recvBuffer []byte
		// 游标
		cursor := uint16(0)
		reader := bufio.NewReader(conn)

		for {
			v, err := reader.ReadByte()
			// var hexString strings.Builder
			// hexString.WriteString(fmt.Sprintf("%02x", v1))
			// hexstr :=hexString.String()
			// v:=[]byte(hexstr)
			//byteArray, err := hex.DecodeString(hexstr)
			if err != nil {
				fmt.Println("Error decoding hex string:", err)
				return
			}
			if err != nil {
				_ = conn.Close()
				return
			}
			switch state {
			case 0x00: // 帧头 2bytes 0xA55A
				if v == 0xa5 {
					state = 0x01
					//初始化
					recvBuffer = nil
					cursor = 0
				} else {
					state = 0x00 
				}
			case 0x01:
				if v == 0x5a {
					state = 0x02
				} else {
					state = 0x00
				}
			case 0x02: // 帧长度 1byte
				if v >= 0x0f {
					length = uint16(v)
					// 一次申请缓存，准备读数据
					recvBuffer = make([]byte, length)
					recvBuffer[0] = 0xA5
					recvBuffer[1] = 0x5A
					recvBuffer[2] = v
					state = 0x03
				} //else {
				// 	state = errState(ip, "长度检测", "帧长度错误，丢弃数据", []byte{v})
				// }
			case 0x03: // 厂家编号 1byte
				recvBuffer[3] = v
				state = 0x04

			case 0x04: // 协议版本 1byte
				recvBuffer[4] = v
				state = 0x05

			case 0x05: // 帧类型 1byte
				recvBuffer[5] = v
				state = 0x06

			case 0x06: // 设备编号 4bytes
				recvBuffer[6+cursor] = v
				cursor++
				if cursor == 4 {
					// 恢复游标，待读取数据备用
					cursor = 0
					// 如果数据段为空则跳过
					if (length - 15) != 0 {
						state = 0x07
					} else {
						state = 0x08
					}
				}
			case 0x07: // 信息段 Nbytes
				recvBuffer[10+cursor] = v
				//fmt.Print("intVar: ", v, "\n")
				cursor++
				if cursor == (length - 15) {
					state = 0x08
				}
			case 0x08: // 校验和 1byte
				recvBuffer[length - 5] = v
				state = 0x09
			case 0x09: // 帧尾 4bytes 0xCC33C33C
				recvBuffer[length - 4] = 0xCC
				recvBuffer[length - 3] = 0x33
				recvBuffer[length - 2] = 0xC3
				recvBuffer[length - 1] = 0x3C

				if recvBuffer[2]==103{
					a1 := BytesToHex(recvBuffer[10:30])
					tcpChan <- a1 
					a2,err := strconv.ParseInt(BytesToHex(recvBuffer[30:32]), 16, 64) //int
					tcpChan <- string(a2)
					a3,err := strconv.ParseInt(BytesToHex(recvBuffer[32:34]), 16, 64) //int
					tcpChan <- string(a3)
					a4,err := strconv.ParseInt(BytesToHex(recvBuffer[34:35]), 16, 64) //int
					tcpChan <- string(a4)
					a5,err := HexToDecimalWithTwoDecimalPlaces(BytesToHex(recvBuffer[35:39]))//float
					tcpChan <- a5
					a6,err := HexToDecimalWithTwoDecimalPlaces(BytesToHex(recvBuffer[39:43]))//float
					tcpChan <- a6
					a7,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[43:47]))//float
					tcpChan <- a7
					a8,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[47:51]))//float
					tcpChan <- a8
					a9,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[51:55]))//float
					tcpChan <- a9
					a10,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[55:59]))//float
					tcpChan <- a10
					a11,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[59:63]))//float
					tcpChan <- a11
					a12,err := HexToDecimalWithTwoDecimalPlaces2(BytesToHex(recvBuffer[63:67]))//float
					tcpChan <- a12
					a13,err := HexToDecimalWithTwoDecimalPlaces2(BytesToHex(recvBuffer[67:71]))//float
					tcpChan <- a13
					a14,err := HexToDecimalWithTwoDecimalPlaces(BytesToHex(recvBuffer[71:75]))//float
					tcpChan <- a14
					a15,err := HexToDecimalWithTwoDecimalPlaces(BytesToHex(recvBuffer[75:79]))//float
					tcpChan <- a15
					a16,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[79:83]))//float
					tcpChan <- a16
					a17,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[83:87]))//float
					tcpChan <- a17
					a18,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[87:91]))//float
					tcpChan <- a18
					a19,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[91:95]))//float
					tcpChan <- a19
					a20,err := strconv.ParseInt(BytesToHex(recvBuffer[95:96]), 16, 64)//int
					tcpChan <- string(a20)
					a21,err := strconv.ParseInt(BytesToHex(recvBuffer[96:97]), 16, 64)//int
					tcpChan <- string(a21)
					a22,err := strconv.ParseInt(BytesToHex(recvBuffer[97:98]), 16, 64)//int
					tcpChan <- string(a22)
					//a23,err := strconv.ParseInt(recvBuffer(buffer[:]), 16, 64)
					//a24,err := string(recvBuffer[:])
					// a25,err := strconv.ParseInt(string(buffer[:]), 16, 64)
					// a26,err := string(recvBuffer[:])
					a23 := BytesToHex(recvBuffer[98:99])
					fmt.Print("intVar: ", a7, "\n")
					if err != nil {
						log.Fatal(err)
					}
					_, err1 := db.Exec("insert into dvinf(SIM卡号,群塔ID,塔ID,吊绳倍率,塔机X坐标,塔机Y坐标,塔机前臂长度,塔机后臂长度,塔帽高度,塔身高度,安装经度,安装纬度,左转最大角度,右转最大角度,小车前行最远点到塔臂前端距离,小车回收最近到塔臂前端距离,钩起升的最高点离塔臂的距离,塔机支持的最大起重量,力矩限位最大值,预警百分比,报警百分比,违章百分比,校验和)values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19,a20,a21,a22,a23)
					if err1 != nil {
						log.Fatal(err1)
					}
					recvBuffer[5] =0x03
					recvBuffer[10] =recvBuffer[98]
					recvBuffer[11] = recvBuffer[99]
					recvBuffer[12] = recvBuffer[100]
					recvBuffer[13] = recvBuffer[101]
					recvBuffer[14] = recvBuffer[102]
					// 将接收到的数据发送回客户端
					_, err = conn.Write(recvBuffer[:15])
					if err != nil {
						log.Println("发送数据失败:", err)
						break
					}
				}
				if recvBuffer[2]==65{
						b0 := BytesToHexWithPrefix(recvBuffer[10:14])
						b01,err :=CombineHexWithPrefixPerByte(b0)
						b1,err := hexToTime(b01)
						b2,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[14:18]))//float
						b3,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[18:22]))//float
						b4,err := HexToDecimalWithTwoDecimalPlaces(BytesToHex(recvBuffer[22:26]))//float
						b5,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[26:30]))//float
						b6,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[30:34]))//float
						b7,err := strconv.ParseInt(BytesToHex(recvBuffer[34:35]), 16, 64)//int
						b8,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[35:39]))//float
						b9,err := strconv.ParseInt(BytesToHex(recvBuffer[39:40]), 16, 64)//int
						b10,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[40:44]))//float
						b11,err := HexToDecimalWithTwoDecimalPlaces(BytesToHex(recvBuffer[44:48]))//float
						b12,err := HexToDecimalWithTwoDecimalPlaces(BytesToHex(recvBuffer[48:52]))//float
						b13,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[52:56]))//float
						b14,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[56:60]))//float
						b15 := BytesToHex(recvBuffer[60:61])
						if err != nil {
							log.Fatal(err)
						}
						_, err2 := db.Exec("insert into rtdata1(上传时间戳,高度,幅度,转角,载重,安全载重,安全载重百分比,力矩,力矩载重百分比,当前风速,倾斜角度X,倾斜角度Y,设备状态,下降深度,校验和)values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11,b12,b13,b14,b15)
						if err2 != nil { 
							log.Fatal(err2)
						}
						recvBuffer[5] =0x07
						recvBuffer[10] =recvBuffer[60]
						recvBuffer[11] = recvBuffer[61]
						recvBuffer[12] = recvBuffer[62]
						recvBuffer[13] = recvBuffer[63]
						recvBuffer[14] = recvBuffer[64]
						// 将接收到的数据发送回客户端
						_, err = conn.Write(recvBuffer[:15])
						if err != nil {
							log.Println("发送数据失败:", err)
							break
						}
				}
				if recvBuffer[2]==93{
					c00 := BytesToHexWithPrefix(recvBuffer[10:14])
					c01:= BytesToHexWithPrefix(recvBuffer[14:18])
					c02:= BytesToHexWithPrefix(recvBuffer[18:22])
					c04,err := CombineHexWithPrefixPerByte(c00)
					c05,err := CombineHexWithPrefixPerByte(c01)
					c06,err := CombineHexWithPrefixPerByte(c02)
					c1,err := hexToTime(c04)
					c2,err := hexToTime(c05)
					c3,err := hexToTime(c06)
					c4,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[22:26]))
					c5,err := strconv.ParseInt(BytesToHex(recvBuffer[26:27]),16,64)
					c6,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[27:31]))
					c7,err := strconv.ParseInt(BytesToHex(recvBuffer[31:32]),16,64)
					c8,err := HexToDecimalWithTwoDecimalPlaces(BytesToHex(recvBuffer[32:36]))
					c9,err := HexToDecimalWithTwoDecimalPlaces(BytesToHex(recvBuffer[36:40]))
					c10,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[40:44]))
					c11,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[44:48]))
					c12,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[48:52]))
					c13,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[52:56]))
					c14,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[56:60]))
					c15,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[60:64]))
					c16,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[64:68]))
					c17,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[68:72]))
					c18,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[72:76]))
					c19,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[76:80]))
					c20,err := HexToDecimalWithTwoDecimalPlaces1(BytesToHex(recvBuffer[80:84]))
					c03 := BytesToHexWithPrefix(recvBuffer[84:88])
					c21,err := CombineHexWithPrefixPerByte(c03)
					c22 := BytesToHex(recvBuffer[88:89])
					if err != nil {
						log.Fatal(err)
					}
					_, err2 := db.Exec("insert into dzdata1(上传时间戳,吊装开始时间戳,吊装结束时间戳,最大载重,最大载重百分比,最大力矩,最大力矩百分比,开始转角,结束转角,开始幅度,结束幅度,最大工作幅度,最小工作幅度,开始起升高度,结束起升高度,最大起升高度,最小起升高度,最大风速,最大倾角X,最大倾角Y,设备状态,校验和)values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? ,?)", c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13,c14,c15,c16,c17,c18,c19,c20,c21,c22)
					if err2 != nil {
						log.Fatal(err2)
					}
					recvBuffer[5] =0x09
					recvBuffer[10] =recvBuffer[88]
					recvBuffer[11] = recvBuffer[89]
					recvBuffer[12] = recvBuffer[90]
					recvBuffer[13] = recvBuffer[91]
					recvBuffer[14] = recvBuffer[92]
					// 将接收到的数据发送回客户端
					_, err = conn.Write(recvBuffer[:15])
					if err != nil {
						log.Println("发送数据失败:", err)
						break
					}


					//var buf []string
					// for len(tcpChan) > 0 {
					// 	buf = append(buf, <-tcpChan)
					// }

					// // 打印缓冲的内容
					// for _, s := range buf {
					// 	fmt.Println(s)
					// }
				}
				if recvBuffer[2]==19{
					recvBuffer[5] =0x01
					// 将接收到的数据发送回客户端
					_, err = conn.Write(recvBuffer[:19])
					if err != nil {
						log.Println("发送数据失败:", err)
						break
					}
				}

				if recvBuffer[2]==15{
					recvBuffer[5] =0x05
					// 将接收到的数据发送回客户端
					_, err = conn.Write(recvBuffer[:15])
					if err != nil {
						log.Println("发送数据失败:", err)
						break
					}
				}
				state = 0x00
			}



		//1、心跳包
		// if buffer.String() == "heartbeat" {
		// 	heartbeatTimer.Reset(heartbeatTimeout)
		// 	continue
		// }
		// fmt.Printf("Al\n")
		// //2、设备属性信息
		// if n==206{
		// 	a1 := string(buffer[20:60])
		// 	a2,err := strconv.ParseInt(string(buffer[60:64]), 16, 64) //int
		// 	a3,err := strconv.ParseInt(string(buffer[64:68]), 16, 64) //int
		// 	a4,err := strconv.ParseInt(string(buffer[68:70]), 16, 64) //int
		// 	a5,err := HexToDecimalWithTwoDecimalPlaces(string(buffer[70:78]))//float
		// 	a6,err := HexToDecimalWithTwoDecimalPlaces(string(buffer[78:86]))//float
		// 	a7,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[86:94]))//float
		// 	a8,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[94:102]))//float
		// 	a9,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[102:110]))//float
		// 	a10,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[110:118]))//float
		// 	a11,err := HexToDecimalWithTwoDecimalPlaces2(string(buffer[118:126]))//float
		// 	a12,err := HexToDecimalWithTwoDecimalPlaces2(string(buffer[126:134]))//float
		// 	a13,err := HexToDecimalWithTwoDecimalPlaces(string(buffer[134:142]))//float
		// 	a14,err := HexToDecimalWithTwoDecimalPlaces(string(buffer[142:150]))//float
		// 	a15,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[150:158]))//float
		// 	a16,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[158:166]))//float
		// 	a17,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[166:174]))//float
		// 	a18,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[174:182]))//float
		// 	a19,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[182:190]))//float
		// 	a20,err := strconv.ParseInt(string(buffer[190:192]), 16, 64)//int
		// 	a21,err := strconv.ParseInt(string(buffer[192:194]), 16, 64)//int
		// 	a22,err := strconv.ParseInt(string(buffer[194:196]), 16, 64)//int
		// 	a23,err := strconv.ParseInt(string(buffer[:]), 16, 64)
		// 	a24,err := string(buffer[:])
		// 	a25,err := strconv.ParseInt(string(buffer[:]), 16, 64)
		// 	a26,err := string(buffer[:])
		// 	a27,err := string(buffer[:])
		// 	fmt.Print("intVar: ", a13, "\n")
		// 	if err != nil {
		// 		log.Fatal(err)
		// 	}
		// 	_, err1 := db.Exec("insert into dvinf(SIM卡号,群塔ID,塔ID,吊绳倍率,塔机X坐标,塔机Y坐标,塔机前臂长度,塔机后臂长度,塔帽高度,塔身高度,安装经度,安装纬度,左转最大角度,右转最大角度,小车前行最远点到塔臂前端距离,小车回收最近到塔臂前端距离,钩起升的最高点离塔臂的距离,塔机支持的最大起重量,力矩限位最大值,预警百分比,报警百分比,违章百分比,帧长度,厂家编号,协议版本,设备编号,校验和)values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19,a20,a21,a22,a23,a24,a25,a26,a27)
		// 	if err1 != nil {
		// 		log.Fatal(err1)
		// 	}
		// }
		// //3、设备实时数据
		// if n==130{
		// 	b1,err := HexToPrefixedHex(string(buffer[20:28]))
		// 	b2,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[28:36]))//float
		// 	b3,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[36:44]))//float
		// 	b4,err := HexToDecimalWithTwoDecimalPlaces(string(buffer[44:52]))//float
		// 	b5,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[52:60]))//float
		// 	b6,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[60:68]))//float
		// 	b7,err := strconv.ParseInt(string(buffer[68:70]), 16, 64)//int
		// 	b8,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[70:78]))//float
		// 	b9,err := strconv.ParseInt(string(buffer[78:80]), 16, 64)//int
		// 	b10,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[80:88]))//float
		// 	b11,err := HexToDecimalWithTwoDecimalPlaces(string(buffer[88:96]))//float
		// 	b12,err := HexToDecimalWithTwoDecimalPlaces(string(buffer[96:104]))//float
		// 	b13,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[104:112]))//float
		// 	b14,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[112:120]))//float
		// 	if err != nil {
		// 		log.Fatal(err)
		// 	}
			
		// 	_, err2 := db.Exec("insert into rtdata(上传时间戳,高度,幅度,转角,载重,安全载重,安全载重百分比,力矩,力矩载重百分比,当前风速,倾斜角度X,倾斜角度Y,设备状态,下降深度)values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11,b12,b13,b14)
		// 	if err2 != nil { 
		// 		log.Fatal(err2)
		// 	}
		// }
		// //4、吊装数据上传
		// if n==186{
		// 	c1,err := HexToPrefixedHex(string(buffer[20:28]))
		// 	c2,err := HexToPrefixedHex(string(buffer[28:36]))
		// 	c3,err := HexToPrefixedHex(string(buffer[36:44]))
		// 	c4,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[44:52]))
		// 	c5,err := strconv.ParseInt(string(buffer[52:54]),16,64)
		// 	c6,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[54:62]))
		// 	c7,err := strconv.ParseInt(string(buffer[62:64]),16,64)
		// 	c8,err := HexToDecimalWithTwoDecimalPlaces(string(buffer[64:72]))
		// 	c9,err := HexToDecimalWithTwoDecimalPlaces(string(buffer[72:80]))
		// 	c10,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[80:88]))
		// 	c11,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[88:96]))
		// 	c12,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[96:104]))
		// 	c13,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[104:112]))
		// 	c14,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[112:120]))
		// 	c15,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[120:128]))
		// 	c16,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[128:136]))
		// 	c17,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[136:144]))
		// 	c18,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[144:152]))
		// 	c19,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[152:160]))
		// 	c20,err := HexToDecimalWithTwoDecimalPlaces1(string(buffer[160:168]))
		// 	c21,err := HexToPrefixedHex(string(buffer[168:176]))
		// 	if err != nil {
		// 		log.Fatal(err)
		// 	}
		// 	_, err2 := db.Exec("insert into dzdata(上传时间戳,吊装开始时间戳,吊装结束时间戳,最大载重,最大载重百分比,最大力矩,最大力矩百分比,开始转角,结束转角,开始幅度,结束幅度,最大工作幅度,最小工作幅度,开始起升高度,结束起升高度,最大起升高度,最小起升高度,最大风速,最大倾角X,最大倾角Y,设备状态)values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13,c14,c15,c16,c17,c18,c19,c20,c21)
		// 	if err2 != nil {
		// 		log.Fatal(err2)
		// 	}
		// }
		// // //5、设备注册
		// // if n==38	{
		// // 	register := buffer[20:27]
		// // 	type4 := buffer[10:11]
		// // }
		// //todo mysql
		

		// //push websocket

		// // 将接收到的数据发送回客户端
		// _, err = conn.Write(buffer[:n])
		// if err != nil {
		// 	log.Println("发送数据失败:", err)
		// 	break
		// }
	//}
}
}


